home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / MATH / MATHLIB / MATHTIME.PAS < prev    next >
Pascal/Delphi Source File  |  1993-06-21  |  16KB  |  530 lines
  1. {$N+}
  2. PROGRAM Quick;
  3. USES    MathLib, TrigStuff, TPTimer;
  4. CONST   max = 6;
  5. VAR     r,s,t,w,x,y,z: DOUBLE;
  6.         k,l,m,n: INTEGER;
  7.         nums: floatray;
  8.         start, finis: LONGINT;
  9.         baseline, base, base1, time, time2: REAL;
  10.         i,j,counter: LONGINT;
  11.         outfile: TEXT;
  12.         ch: CHAR;
  13.         
  14.   PROCEDURE WriteIt(base:REAL);
  15.   
  16.     BEGIN
  17.       finis := ReadTimer;
  18.       time2 := ElapsedTime(start,finis)/1000 - base;
  19.       WRITELN(outfile, time2:6:2, time2/time:6:2);
  20.       WRITELN(         time2:6:2, time2/time:6:2);
  21.     END;
  22.  
  23.   BEGIN
  24.     WRITE('Input number of trials: ');
  25.     READLN(counter);
  26.     Randomize;
  27.     ASSIGN(outfile, 'MATHTIME.DAT');
  28.     REWRITE(outfile);
  29.     start := ReadTimer;
  30.     FOR i := 0 TO counter DO BEGIN
  31.       x := 1.0E6*Random;
  32.     END;
  33.     finis := ReadTimer;
  34.     baseline := ElapsedTime(start,finis)/1000;
  35.     WRITELN;
  36.     WRITELN(         '           MATHLIB   SYS  Ratio');
  37.     WRITELN(outfile);
  38.     WRITELN(outfile,         '           MATHLIB   SYS  Ratio');
  39.     start := ReadTimer;
  40.     FOR i := 0 TO counter DO BEGIN
  41.       x := 1.0E6*Random;
  42.       y := MATHLIB.LN(x);
  43.     END;
  44.     finis := ReadTimer;
  45.     time := ElapsedTime(start,finis)/1000 - baseline;
  46.     WRITE(outfile, 'LN:         ',time:6:2);
  47.     WRITE(         'LN:         ',time:6:2);
  48.     start := ReadTimer;
  49.     FOR i := 0 TO counter DO BEGIN
  50.       x := 1.0E6*Random;
  51.       y := SYSTEM.LN(x);
  52.     END;
  53.     WriteIt(baseline);
  54.     start := ReadTimer;
  55.     FOR i := 0 TO counter DO BEGIN
  56.       x := 1.0E6*Random;
  57.       y := MATHLIB.LOG(x);
  58.     END;
  59.     finis := ReadTimer;
  60.     time := ElapsedTime(start,finis)/1000 - baseline;
  61.     WRITE(outfile, 'LOG:        ',time:6:2);
  62.     WRITE(         'LOG:        ',time:6:2);
  63.     start := ReadTimer;
  64.     FOR i := 0 TO counter DO BEGIN
  65.       x := 1.0E6*Random;
  66.       y := TRIGSTUFF.LOG(x);
  67.     END;
  68.     WriteIt(baseline);
  69.     start := ReadTimer;
  70.     FOR i := 0 TO counter DO BEGIN
  71.       x := -100 + 200*Random;
  72.       y := MATHLIB.Two2TheX(x);
  73.     END;
  74.     finis := ReadTimer;
  75.     time := ElapsedTime(start,finis)/1000 - baseline;
  76.     WRITE(outfile, 'Two2TheX:   ',time:6:2);
  77.     WRITE(         'Two2TheX:   ',time:6:2);
  78.     start := ReadTimer;
  79.     FOR i := 0 TO counter DO BEGIN
  80.       x := -100 + 200*Random;
  81.       y := TRIGSTUFF.Two2TheX(x);
  82.     END;
  83.     WriteIt(baseline);
  84.     start := ReadTimer;
  85.     FOR i := 0 TO counter DO BEGIN
  86.       x := -100 + 200*Random;
  87.       y := MATHLIB.EXP(x);
  88.     END;
  89.     finis := ReadTimer;
  90.     time := ElapsedTime(start,finis)/1000 - baseline;
  91.     WRITE(outfile, 'EXP:        ',time:6:2);
  92.     WRITE(         'EXP:        ',time:6:2);
  93.     start := ReadTimer;
  94.     FOR i := 0 TO counter DO BEGIN
  95.       x := -100 + 200*Random;
  96.       y := SYSTEM.EXP(x);
  97.     END;
  98.     WriteIt(baseline);
  99.     start := ReadTimer;
  100.     FOR i := 0 TO counter DO BEGIN
  101.       x := -10 + 20*Random;
  102.       y := MATHLIB.Ten2TheX(x);
  103.     END;
  104.     finis := ReadTimer;
  105.     time := ElapsedTime(start,finis)/1000 - baseline;
  106.     WRITE(outfile, 'Ten2TheX:   ',time:6:2);
  107.     WRITE(         'Ten2TheX:   ',time:6:2);
  108.     start := ReadTimer;
  109.     FOR i := 0 TO counter DO BEGIN
  110.       x := -10 + 20*Random;
  111.       y := TRIGSTUFF.Ten2TheX(x);
  112.     END;
  113.     WriteIt(baseline);
  114.     start := ReadTimer;
  115.     FOR i := 0 TO counter DO BEGIN
  116.       x := 10*Random;
  117.       y := -10 + 20*Random;
  118.       s := MATHLIB.Expo(x,y);
  119.     END;
  120.     finis := ReadTimer;
  121.     time := ElapsedTime(start,finis)/1000 - 2*baseline;
  122.     WRITE(outfile, 'Expo:       ',time:6:2);
  123.     WRITE(         'Expo:       ',time:6:2);
  124.     start := ReadTimer;
  125.     FOR i := 0 TO counter DO BEGIN
  126.       x := 10*Random;
  127.       y := -10 + 20*Random;
  128.       s := TRIGSTUFF.Expo(x,y);
  129.     END;
  130.     WriteIt(2*baseline);
  131.     start := ReadTimer;
  132.     FOR i := 0 TO counter DO BEGIN
  133.       x := -1.0E6 + 2.0E6*Random;
  134.       y := MATHLIB.TAN(x);
  135.     END;
  136.     finis := ReadTimer;
  137.     time := ElapsedTime(start,finis)/1000 - baseline;
  138.     WRITE(outfile, 'TAN:        ',time:6:2);
  139.     WRITE(         'TAN:        ',time:6:2);
  140.     start := ReadTimer;
  141.     FOR i := 0 TO counter DO BEGIN
  142.       x := -1.0E6 + 2.0E6*Random;
  143.       y := TRIGSTUFF.TAN(x);
  144.     END;
  145.     WriteIt(baseline);
  146.     start := ReadTimer;
  147.     FOR i := 0 TO counter DO BEGIN
  148.       x := -1.0E6 + 2.0E6*Random;
  149.       y := MATHLIB.SIN(x);
  150.     END;
  151.     finis := ReadTimer;
  152.     time := ElapsedTime(start,finis)/1000 - baseline;
  153.     WRITE(outfile, 'SIN:        ',time:6:2);
  154.     WRITE(         'SIN:        ',time:6:2);
  155.     start := ReadTimer;
  156.     FOR i := 0 TO counter DO BEGIN
  157.       x := -1.0E6 + 2.0E6*Random;
  158.       y := SYSTEM.SIN(x);
  159.     END;
  160.     WriteIt(baseline);
  161.     start := ReadTimer;
  162.     FOR i := 0 TO counter DO BEGIN
  163.       x := -1.0E6 + 2.0E6*Random;
  164.       y := MATHLIB.COS(x);
  165.     END;
  166.     finis := ReadTimer;
  167.     time := ElapsedTime(start,finis)/1000 - baseline;
  168.     WRITE(outfile, 'COS:        ',time:6:2);
  169.     WRITE(         'COS:        ',time:6:2);
  170.     start := ReadTimer;
  171.     FOR i := 0 TO counter DO BEGIN
  172.       x := -1.0E6 + 2.0E6*Random;
  173.       y := SYSTEM.COS(x);
  174.     END;
  175.     WriteIt(baseline);
  176.     start := ReadTimer;
  177.     FOR i := 0 TO counter DO BEGIN
  178.       x := -1.0E6 + 2.0E6*Random;
  179.       MATHLIB.SINCOS(x,y,s);
  180.     END;
  181.     finis := ReadTimer;
  182.     time := ElapsedTime(start,finis)/1000 - baseline;
  183.     WRITE(outfile, 'SINCOS:     ',time:6:2);
  184.     WRITE(         'SINCOS:     ',time:6:2);
  185.     start := ReadTimer;
  186.     FOR i := 0 TO counter DO BEGIN
  187.       x := -1.0E6 + 2.0E6*Random;
  188.       TRIGSTUFF.SINCOS(x,y,s);
  189.     END;
  190.     WriteIt(baseline);
  191.     start := ReadTimer;
  192.     FOR i := 0 TO counter DO BEGIN
  193.       x := -100 + 200*Random;
  194.       y := MATHLIB.ARCTAN(x);
  195.     END;
  196.     finis := ReadTimer;
  197.     time := ElapsedTime(start,finis)/1000 - baseline;
  198.     WRITE(outfile, 'ARCTAN:     ',time:6:2);
  199.     WRITE(         'ARCTAN:     ',time:6:2);
  200.     start := ReadTimer;
  201.     FOR i := 0 TO counter DO BEGIN
  202.       x := -100 + 200*Random;
  203.       y := SYSTEM.ARCTAN(x);
  204.     END;
  205.     WriteIt(baseline);
  206.     start := ReadTimer;
  207.     FOR i := 0 TO counter DO BEGIN
  208.       x := -100 + 200*Random;
  209.       y := -100 + 200*Random;
  210.       s := MATHLIB.ArcTangent(x,y);
  211.     END;
  212.     finis := ReadTimer;
  213.     time := ElapsedTime(start,finis)/1000 - 2*baseline;
  214.     WRITE(outfile, 'ArcTangent: ',time:6:2);
  215.     WRITE(         'ArcTangent: ',time:6:2);
  216.     start := ReadTimer;
  217.     FOR i := 0 TO counter DO BEGIN
  218.       x := -100 + 200*Random;
  219.       y := -100 + 200*Random;
  220.       s := TRIGSTUFF.ArcTangent(x,y);
  221.     END;
  222.     WriteIt(2*baseline);
  223.     start := ReadTimer;
  224.     FOR i := 0 TO counter DO BEGIN
  225.       x := -1.0+2.0*Random;
  226.       y := MATHLIB.ARCSIN(x);
  227.     END;
  228.     finis := ReadTimer;
  229.     time := ElapsedTime(start,finis)/1000 - baseline;
  230.     WRITE(outfile, 'ARCSIN:     ',time:6:2);
  231.     WRITE(         'ARCSIN:     ',time:6:2);
  232.     start := ReadTimer;
  233.     FOR i := 0 TO counter DO BEGIN
  234.       x := -1.0+2.0*Random;
  235.       y := TRIGSTUFF.ARCSIN(x);
  236.     END;
  237.     WriteIt(baseline);
  238.     start := ReadTimer;
  239.     FOR i := 0 TO counter DO BEGIN
  240.       x := -1.0+2.0*Random;
  241.       y := MATHLIB.ARCCOS(x);
  242.     END;
  243.     finis := ReadTimer;
  244.     time := ElapsedTime(start,finis)/1000 - baseline;
  245.     WRITE(outfile, 'ARCCOS:     ',time:6:2);
  246.     WRITE(         'ARCCOS:     ',time:6:2);
  247.     start := ReadTimer;
  248.     FOR i := 0 TO counter DO BEGIN
  249.       x := -1.0+2.0*Random;
  250.       y := TRIGSTUFF.ARCCOS(x);
  251.     END;
  252.     WriteIt(baseline);
  253.     start := ReadTimer;
  254.     FOR i := 0 TO counter DO BEGIN
  255.       x := -10 + 20*Random;
  256.     END;
  257.     finis := ReadTimer;
  258.     base1 := ElapsedTime(start,finis)/1000;
  259.     start := ReadTimer;
  260.     FOR i := 0 TO counter DO BEGIN
  261.       x := -100 + 200*Random;
  262.     END;
  263.     finis := ReadTimer;
  264.     base := ElapsedTime(start,finis)/1000;
  265.     start := ReadTimer;
  266.     FOR i := 0 TO counter DO BEGIN
  267.       x := -100 + 200*Random;
  268.       w := MATHLIB.CEIL(x);
  269.     END;
  270.     finis := ReadTimer;
  271.     time := ElapsedTime(start,finis)/1000 - base;
  272.     WRITE(outfile, 'CEIL:       ',time:6:2);
  273.     WRITE(         'CEIL:       ',time:6:2);
  274.     start := ReadTimer;
  275.     FOR i := 0 TO counter DO BEGIN
  276.       x := -100 + 200*Random;
  277.       z := TRIGSTUFF.CEIL(x);
  278.     END;
  279.     WriteIt(base);
  280.     start := ReadTimer;
  281.     FOR i := 0 TO counter DO BEGIN
  282.       x := -100 + 200*Random;
  283.     END;
  284.     finis := ReadTimer;
  285.     base := ElapsedTime(start,finis)/1000;
  286.     start := ReadTimer;
  287.     FOR i := 0 TO counter DO BEGIN
  288.       x := -100 + 200*Random;
  289.       w := MATHLIB.FLOOR(x);
  290.     END;
  291.     finis := ReadTimer;
  292.     time := ElapsedTime(start,finis)/1000 - base;
  293.     WRITE(outfile, 'FLOOR:      ',time:6:2);
  294.     WRITE(         'FLOOR:      ',time:6:2);
  295.     start := ReadTimer;
  296.     FOR i := 0 TO counter DO BEGIN
  297.       x := -100 + 200*Random;
  298.       z := TRIGSTUFF.FLOOR(x);
  299.     END;
  300.     WriteIt(base);
  301.     start := ReadTimer;
  302.     FOR i := 0 TO counter DO BEGIN
  303.       x := -100 + 200*Random;
  304.       y := -100 + 200*Random;
  305.     END;
  306.     finis := ReadTimer;
  307.     base := ElapsedTime(start,finis)/1000;
  308.     start := ReadTimer;
  309.     FOR i := 0 TO counter DO BEGIN
  310.       x := -100 + 200*Random;
  311.       y := -100 + 200*Random;
  312.       w := MATHLIB.FMOD(x,y);
  313.     END;
  314.     finis := ReadTimer;
  315.     time := ElapsedTime(start,finis)/1000 - base;
  316.     WRITE(outfile, 'FMOD:       ',time:6:2);
  317.     WRITE(         'FMOD:       ',time:6:2);
  318.     start := ReadTimer;
  319.     FOR i := 0 TO counter DO BEGIN
  320.       x := -100 + 200*Random;
  321.       y := -100 + 200*Random;
  322.       z := TRIGSTUFF.FMOD(x,y);
  323.     END;
  324.     WriteIt(base);
  325.     start := ReadTimer;
  326.     FOR i := 0 TO counter DO BEGIN
  327.       x := -100 + 200*Random;
  328.     END;
  329.     finis := ReadTimer;
  330.     base := ElapsedTime(start,finis)/1000;
  331.     start := ReadTimer;
  332.     FOR i := 0 TO counter DO BEGIN
  333.       x := -100 + 200*Random;
  334.       w := MATHLIB.FREXP(x,l);
  335.     END;
  336.     finis := ReadTimer;
  337.     time := ElapsedTime(start,finis)/1000 - base;
  338.     WRITE(outfile, 'FREXP:      ',time:6:2);
  339.     WRITE(         'FREXP:      ',time:6:2);
  340.     start := ReadTimer;
  341.     FOR i := 0 TO counter DO BEGIN
  342.       x := -100 + 200*Random;
  343.       z := TRIGSTUFF.FREXP(x,k);
  344.     END;
  345.     WriteIt(base);
  346.     start := ReadTimer;
  347.     FOR i := 0 TO counter DO BEGIN
  348.       x := -100 + 200*Random;
  349.       y := -100 + 200*Random;
  350.     END;
  351.     finis := ReadTimer;
  352.     base := ElapsedTime(start,finis)/1000;
  353.     start := ReadTimer;
  354.     FOR i := 0 TO counter DO BEGIN
  355.       x := -100 + 200*Random;
  356.       y := -100 + 200*Random;
  357.       w := MATHLIB.HYPOT(x,y);
  358.     END;
  359.     finis := ReadTimer;
  360.     time := ElapsedTime(start,finis)/1000 - base;
  361.     WRITE(outfile, 'HYPOT:      ',time:6:2);
  362.     WRITE(         'HYPOT:      ',time:6:2);
  363.     start := ReadTimer;
  364.     FOR i := 0 TO counter DO BEGIN
  365.       x := -100 + 200*Random;
  366.       y := -100 + 200*Random;
  367.       z := TRIGSTUFF.HYPOT(x,y);
  368.     END;
  369.     WriteIt(base);
  370.     start := ReadTimer;
  371.     FOR i := 0 TO counter DO BEGIN
  372.       x := -100 + 200*Random;
  373.       k := TRUNC(-100 + 200*Random);
  374.     END;
  375.     finis := ReadTimer;
  376.     base := ElapsedTime(start,finis)/1000;
  377.     start := ReadTimer;
  378.     FOR i := 0 TO counter DO BEGIN
  379.       x := -100 + 200*Random;
  380.       k := TRUNC(-100 + 200*Random);
  381.       w := MATHLIB.LDEXP(x,k);
  382.     END;
  383.     finis := ReadTimer;
  384.     time := ElapsedTime(start,finis)/1000 - base;
  385.     WRITE(outfile, 'LDEXP:      ',time:6:2);
  386.     WRITE(         'LDEXP:      ',time:6:2);
  387.     start := ReadTimer;
  388.     FOR i := 0 TO counter DO BEGIN
  389.       x := -100 + 200*Random;
  390.       k := TRUNC(-100 + 200*Random);
  391.       z := TRIGSTUFF.LDEXP(x,k);
  392.     END;
  393.     WriteIt(base);
  394.     start := ReadTimer;
  395.     FOR i := 0 TO counter DO BEGIN
  396.       x := -100 + 200*Random;
  397.     END;
  398.     finis := ReadTimer;
  399.     base := ElapsedTime(start,finis)/1000;
  400.     start := ReadTimer;
  401.     FOR i := 0 TO counter DO BEGIN
  402.       x := -100 + 200*Random;
  403.       w := MATHLIB.MODF(x,r);
  404.     END;
  405.     finis := ReadTimer;
  406.     time := ElapsedTime(start,finis)/1000 - base;
  407.     WRITE(outfile, 'MODF:       ',time:6:2);
  408.     WRITE(         'MODF:       ',time:6:2);
  409.     start := ReadTimer;
  410.     FOR i := 0 TO counter DO BEGIN
  411.       x := -100 + 200*Random;
  412.       z := TRIGSTUFF.MODF(x,y);
  413.     END;
  414.     WriteIt(base);
  415.     start := ReadTimer;
  416.     FOR i := 0 TO counter DO BEGIN
  417.       FOR j := 0 TO max DO nums[j] := 0.2*Random+2*j*Random;
  418.       x := -100 + 200*Random;
  419.     END;
  420.     finis := ReadTimer;
  421.     base := ElapsedTime(start,finis)/1000;
  422.     start := ReadTimer;
  423.     FOR i := 0 TO counter DO BEGIN
  424.       FOR j := 0 TO max DO nums[j] := 0.2*Random+2*j*Random;
  425.       x := -100 + 200*Random;
  426.       w := MATHLIB.POLY(x,max,nums);
  427.     END;
  428.     finis := ReadTimer;
  429.     time := ElapsedTime(start,finis)/1000 - base;
  430.     WRITE(outfile, 'POLY:       ',time:6:2);
  431.     WRITE(         'POLY:       ',time:6:2);
  432.     start := ReadTimer;
  433.     FOR i := 0 TO counter DO BEGIN
  434.       FOR j := 0 TO max DO nums[j] := 0.2*Random+2*j*Random;
  435.       x := -100 + 200*Random;
  436.       z := TRIGSTUFF.POLY(x,max,nums[0]);
  437.     END;
  438.     WriteIt(base);
  439.     start := ReadTimer;
  440.     FOR i := 0 TO counter DO BEGIN
  441.       x := -10 + 20*Random;
  442.       y := MATHLIB.COSH(x);
  443.     END;
  444.     finis := ReadTimer;
  445.     time := ElapsedTime(start,finis)/1000 - base1;
  446.     WRITE(outfile, 'COSH:       ',time:6:2);
  447.     WRITE(         'COSH:       ',time:6:2);
  448.     start := ReadTimer;
  449.     FOR i := 0 TO counter DO BEGIN
  450.       x := -10 + 20*Random;
  451.       y := TRIGSTUFF.COSH(x);
  452.     END;
  453.     WriteIt(base1);
  454.     start := ReadTimer;
  455.     FOR i := 0 TO counter DO BEGIN
  456.       x := -10 + 20*Random;
  457.       y := MATHLIB.SINH(x);
  458.     END;
  459.     finis := ReadTimer;
  460.     time := ElapsedTime(start,finis)/1000 - base1;
  461.     WRITE(outfile, 'SINH:       ',time:6:2);
  462.     WRITE(         'SINH:       ',time:6:2);
  463.     start := ReadTimer;
  464.     FOR i := 0 TO counter DO BEGIN
  465.       x := -10 + 20*Random;
  466.       y := TRIGSTUFF.SINH(x);
  467.     END;
  468.     WriteIt(base1);
  469.     start := ReadTimer;
  470.     FOR i := 0 TO counter DO BEGIN
  471.       x := -10 + 20*Random;
  472.       y := MATHLIB.TANH(x);
  473.     END;
  474.     finis := ReadTimer;
  475.     time := ElapsedTime(start,finis)/1000 - base1;
  476.     WRITE(outfile, 'TANH:       ',time:6:2);
  477.     WRITE(         'TANH:       ',time:6:2);
  478.     start := ReadTimer;
  479.     FOR i := 0 TO counter DO BEGIN
  480.       x := -10 + 20*Random;
  481.       y := TRIGSTUFF.TANH(x);
  482.     END;
  483.     WriteIt(base1);
  484.     start := ReadTimer;
  485.     FOR i := 0 TO counter DO BEGIN
  486.       x := 1 + 19*Random;
  487.       y := MATHLIB.ACOSH(x);
  488.     END;
  489.     finis := ReadTimer;
  490.     time := ElapsedTime(start,finis)/1000 - base1;
  491.     WRITE(outfile, 'ACOSH:      ',time:6:2);
  492.     WRITE(         'ACOSH:      ',time:6:2);
  493.     start := ReadTimer;
  494.     FOR i := 0 TO counter DO BEGIN
  495.       x := 1 + 19*Random;
  496.       y := TRIGSTUFF.ACOSH(x);
  497.     END;
  498.     WriteIt(base1);
  499.     start := ReadTimer;
  500.     FOR i := 0 TO counter DO BEGIN
  501.       x := -10 + 20*Random;
  502.       y := MATHLIB.ASINH(x);
  503.     END;
  504.     finis := ReadTimer;
  505.     time := ElapsedTime(start,finis)/1000 - base1;
  506.     WRITE(outfile, 'ASINH:      ',time:6:2);
  507.     WRITE(         'ASINH:      ',time:6:2);
  508.     start := ReadTimer;
  509.     FOR i := 0 TO counter DO BEGIN
  510.       x := -10 + 20*Random;
  511.       y := TRIGSTUFF.ASINH(x);
  512.     END;
  513.     WriteIt(base1);
  514.     start := ReadTimer;
  515.     FOR i := 0 TO counter DO BEGIN
  516.       x := Random;
  517.       y := MATHLIB.ATANH(x);
  518.     END;
  519.     finis := ReadTimer;
  520.     time := ElapsedTime(start,finis)/1000 - base1;
  521.     WRITE(outfile, 'ATANH:      ',time:6:2);
  522.     WRITE(         'ATANH:      ',time:6:2);
  523.     start := ReadTimer;
  524.     FOR i := 0 TO counter DO BEGIN
  525.       x := Random;
  526.       y := TRIGSTUFF.ATANH(x);
  527.     END;
  528.     WriteIt(base1);
  529.     CLOSE(outfile);
  530.   END.